home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 21 / CU Amiga Magazine's Super CD-ROM 21 (1998)(EMAP Images)(GB)[!][issue 1998-04].iso / CUCD / Programming / RTGMaster / demos / flame.c next >
C/C++ Source or Header  |  1998-01-15  |  8KB  |  325 lines
  1. /*
  2.         Flame
  3.  
  4.         A demo of rtg.library
  5.  
  6.         Written by Thomas & Hans-Jörg Frieden
  7.                    Schlossstr. 176
  8.                    54293 Trier
  9.                    tfrieden@fax.uni-trier.de
  10.                    hfrieden@fix.uni-trier.de
  11.  
  12. */
  13. //* "Includes"
  14. #include <stdlib.h>
  15. #include <proto/utility.h>
  16. #include <proto/exec.h>
  17. #include <clib/rtgmaster_protos.h>
  18. #include <clib/exec_protos.h>
  19. #include <clib/utility_protos.h>
  20. #include <pragmas/rtgmaster_pragmas.h>
  21. #include <pragmas/exec_pragmas.h>
  22. #include <pragmas/utility_pragmas.h>
  23. #include <exec/memory.h>
  24. #include <utility/tagitem.h>
  25. #include <rtgmaster/rtgmaster.h>
  26. #include <rtgmaster/rtgsublibs.h>
  27. #include <rtgmaster/rtgc2p.h>
  28. #include <proto/rtgmaster.h>
  29. #include "timer.h"
  30. #include <string.h>
  31. #include <stdio.h>
  32.  
  33. int currentbuffer=0;
  34.  
  35. //*
  36.  
  37. //* "Defines"
  38. #define XSIZE 80
  39. #define YSIZE 65
  40. #define YSCRN 60
  41. #define MSIZE (XSIZE*YSIZE)
  42. #define DECAY 3
  43. #define CBUF    76800
  44. //*
  45. //* "Pragmas"
  46. extern void __asm CopyFrame(register __a0 UBYTE *adr, 
  47.                             register __d0 ULONG size);
  48. extern void __asm CopyFrame2(register __a0 UBYTE *adr, 
  49.                              register __d0 ULONG aize);
  50. extern void __asm DrawMeter(register __a0 APTR buf, 
  51.                             register __d0 ULONG fps);
  52.  
  53. UBYTE MouseButton(void);
  54. //*
  55. //* "Globals"
  56. struct RtgScreen *RtgScreen;
  57. struct ScreenReq *sr;
  58. struct RTGMasterBase *RTGMasterBase;
  59. struct Library *UtilityBase;
  60. struct TagItem rtag[] = {
  61.     smr_MinWidth,       320,
  62.     smr_MinHeight,      200,
  63.     smr_MaxWidth,       1024,
  64.     smr_MaxHeight,      768,
  65.     smr_ChunkySupport,  512,
  66.     smr_PlanarSupport,  -1,
  67.     smr_Buffers,2,
  68.     TAG_DONE,           NULL
  69. };
  70.  
  71. struct TagItem gtag[] = {
  72.     grd_BytesPerRow,    0,
  73.     grd_Width,          0,
  74.     grd_Height,         0,
  75.     grd_Depth,          0,
  76.     grd_PixelLayout,    0,
  77.     grd_ColorSpace,     0,
  78.     grd_PlaneSize,      0,
  79.     TAG_DONE,           0
  80. };
  81.  
  82. struct TagItem tacks[] = {
  83.     rtg_Buffers,2,
  84.     rtg_Workbench,0,
  85.     TAG_DONE,0
  86. };
  87.  
  88. UBYTE *sc1;
  89. UBYTE scrn[MSIZE];
  90. ULONG cmap[800];
  91. UBYTE blah;
  92. BOOL Planar;
  93. UBYTE *cbuf=NULL;
  94. ULONG width;
  95. ULONG height;
  96. UBYTE *sadr;
  97. ULONG num,avg;
  98. ULONG c2psignal;
  99. //*
  100. //* "NewFrame"
  101. void NewFrame(void) {
  102.     int i,x;
  103.     UBYTE *a;
  104.  
  105.     extern void GenFrame(void);
  106.  
  107.     a=&scrn[MSIZE-1]; i=XSIZE;
  108.  
  109.     while (i>0) {
  110.         x=rand();
  111.         if (x>RAND_MAX/2) *a=255;
  112.         else *a=0;
  113.         i--; a--;
  114.     }
  115.  
  116.     i=MSIZE-XSIZE-1;
  117.     a=scrn;
  118.  
  119.     GenFrame();
  120. }
  121. //*
  122. //* "DrawFrame"
  123. void DrawFrame(struct RtgScreen *s, ULONG size, ULONG ticks) {
  124.  
  125.     if (blah==0) CopyFrame(cbuf, size);
  126.     else CopyFrame2(cbuf,size);
  127.     DrawMeter(cbuf, ticks);  
  128.     CopyRtgBlit(RtgScreen,sadr,cbuf,0,0,0,width,height,width,height,0,0);
  129. }
  130. //*
  131. //* "DrawFrameP"
  132. void DrawFrameP(struct RtgScreen *s, ULONG size, ULONG ticks) {
  133.     UBYTE *adr;
  134.  
  135.     adr=cbuf;                               // Draw into chunky buffer first
  136.     if (blah==0) CopyFrame(adr, 320);
  137.     else CopyFrame2(adr,320);
  138.     DrawMeter(adr, ticks);
  139.     adr = sadr;
  140.     if (tacks[1].ti_Data==512) CopyRtgBlit(RtgScreen,sadr,cbuf,0,0,0,width,height,width,height,0,0);
  141.     // No Doublebuffering, if on Workbench Window
  142.     else
  143.     {
  144.      // For Kalms-c2p we have to use Doublebuffering
  145.      CopyRtgBlit(RtgScreen,GetBufAdr(RtgScreen,1-currentbuffer),cbuf,0,0,0,width,height,width,height,0,0);
  146.      SwitchScreens(RtgScreen,1-currentbuffer);
  147.      currentbuffer=1-currentbuffer;
  148.     }
  149. }
  150. //*
  151. //* "fail"
  152. void fail(void) {
  153.     if (RtgScreen) CloseRtgScreen(RtgScreen);
  154.     if (RTGMasterBase) CloseLibrary((struct Library *)RTGMasterBase);
  155.     if (UtilityBase) CloseLibrary(UtilityBase);
  156.     if (cbuf) FreeMem(cbuf, CBUF);
  157.     exit(0L);
  158. }
  159. //*
  160. //* "main"
  161. void main(int argc, char **argv) {
  162.    /*
  163.     * Since this is a demo, I don't check anything at all
  164.     * and simply assume that every open went ok... 8-)
  165.     */
  166.     int i, x;
  167.     struct TagItem *tag;
  168.     UBYTE rr, rg, rb;
  169.     ULONG size;
  170.     ULONG ticks=0, max=0, min=300;
  171.  
  172.     if (argc>1 && stricmp(argv[1],"small")==0) blah=1; else blah=0;
  173.     if (argc>2 && stricmp(argv[2],"window")==0) tacks[1].ti_Data=LUT8;
  174.     if (argc>1 && stricmp(argv[1],"window")==0) tacks[1].ti_Data=LUT8;
  175.         if (InitTimer()==FALSE) {
  176.         printf("Unable to open timer device\n");
  177.         fail();
  178.     }
  179.  
  180.     RTGMasterBase = (struct RTGMasterBase *)OpenLibrary((STRPTR)"rtgmaster.library", 0);
  181.     UtilityBase = OpenLibrary((STRPTR)"utility.library", 37L);
  182.     c2psignal=AllocSignal(-1);
  183.     sr = RtgScreenModeReq(rtag);
  184.  
  185.     if (sr==NULL) fail();
  186.     if (c2psignal==-1) fail();
  187.     RtgScreen = OpenRtgScreen(sr, tacks);
  188.  
  189.     GetRtgScreenData(RtgScreen, gtag);
  190.  
  191.     tag=FindTagItem(grd_BytesPerRow, gtag);
  192.     size = tag->ti_Data;
  193.  
  194.     tag=FindTagItem(grd_Width, gtag);
  195.     width = tag->ti_Data;
  196.  
  197.     tag=FindTagItem(grd_Height,gtag);
  198.     height = tag->ti_Data;
  199.  
  200.     tag=FindTagItem(grd_PixelLayout, gtag);
  201.     if (tag->ti_Data != grd_PLANAR && tag->ti_Data != grd_CHUNKY) {
  202.         printf("Screenmode not supported\n");
  203.         fail();
  204.     }
  205.  
  206.     if (tag->ti_Data == grd_PLANAR) Planar = TRUE;
  207.     else Planar = FALSE;
  208.  
  209.     printf("Screen is %ld x %ld x %ld\n", gtag[1].ti_Data, gtag[2].ti_Data, gtag[3].ti_Data);
  210.     printf("It has %ld bytes per row", size);
  211.     if (size>gtag[1].ti_Data) {
  212.         printf(", which means that the screen is wider than what you see\n");
  213.     } else printf("\n");
  214.  
  215.         cbuf = AllocMem(CBUF, MEMF_CLEAR|MEMF_FAST);
  216.         if (cbuf==NULL) {
  217.             cbuf=AllocMem(CBUF, MEMF_CLEAR);
  218.             if (cbuf==NULL) {
  219.                 printf("Out of memory *SIGH*\n");
  220.                 fail();
  221.             }
  222.         }
  223.  
  224. if (gtag[3].ti_Data==8)
  225. {
  226.     cmap[0] = 256 * 65536;
  227.     rr = 0;
  228.     rg = 0;
  229.     rb = 0;
  230.     x = 1;
  231.     for (i = 0; i < 64; i++) {
  232.         cmap[x++] = rr * 0x1111111;
  233.         cmap[x++] = rg * 0x1111111;
  234.         cmap[x++] = rb * 0x1111111;
  235.         rr += 3;
  236.     }
  237.     for (i = 0; i < 127; i++) {
  238.         cmap[x++] = rr * 0x1111111;
  239.         cmap[x++] = rg * 0x1111111;
  240.         cmap[x++] = rb * 0x1111111;
  241.         rg += 3;
  242.     }
  243.     for (i = 0; i < 60; i++) {
  244.         cmap[x++] = rr * 0x1111111;
  245.         cmap[x++] = rg * 0x1111111;
  246.         cmap[x++] = rb * 0x1111111;
  247.         rb += 3;
  248.     }
  249.     for (i = 0; i < 4; i++) {
  250.         cmap[x++]=0xFFFFFFFF;
  251.         cmap[x++]=0xFFFFFFFF;
  252.         cmap[x++]=0xFFFFFFFF;
  253.     }
  254.     cmap[x++]=0;
  255. }
  256. else
  257. {
  258.    cmap[0] = 64 * 65536;
  259.     rr = 0;
  260.     rg = 0;
  261.     rb = 0;
  262.     x = 1;
  263.     for (i = 0; i < 16; i++) {
  264.         cmap[x++] = rr * 0x1111111;
  265.         cmap[x++] = rg * 0x1111111;
  266.         cmap[x++] = rb * 0x1111111;
  267.         rr += 12;
  268.     }
  269.     for (i = 0; i < 31; i++) {
  270.         cmap[x++] = rr * 0x1111111;
  271.         cmap[x++] = rg * 0x1111111;
  272.         cmap[x++] = rb * 0x1111111;
  273.         rg += 12;
  274.     }
  275.     for (i = 0; i < 12; i++) {
  276.         cmap[x++] = rr * 0x1111111;
  277.         cmap[x++] = rg * 0x1111111;
  278.         cmap[x++] = rb * 0x1111111;
  279.         rb += 12;
  280.     }
  281.     for (i = 0; i < 4; i++) {
  282.         cmap[x++]=0xFFFFFFFF;
  283.         cmap[x++]=0xFFFFFFFF;
  284.         cmap[x++]=0xFFFFFFFF;
  285.     }
  286.     cmap[x++]=0;
  287. }
  288.     LockRtgScreen(RtgScreen);
  289.     LoadRGBRtg(RtgScreen, (APTR) cmap);
  290.     UnlockRtgScreen(RtgScreen);
  291.  
  292.     if (RtgScreen) {
  293.         LockRtgScreen(RtgScreen);
  294.         sadr = (UBYTE *)GetBufAdr(RtgScreen,0);
  295.  
  296.         num=0;
  297.         while(MouseButton()==0) {
  298.             StartClock();
  299.             NewFrame();
  300.             if (Planar==FALSE) DrawFrame(RtgScreen, size, ticks);
  301.             else DrawFrameP(RtgScreen, size, ticks);
  302.             ticks=StopClock();
  303.             num++;
  304.             avg+=ticks;
  305.             if (max<ticks) max=ticks;
  306.             if (min>ticks) min=ticks;
  307.         }
  308.         UnlockRtgScreen(RtgScreen);
  309.         CloseRtgScreen(RtgScreen);
  310.     }
  311.     if (max==0) max=1;
  312.     if (min==0) min=1;
  313.     printf("Min Frame rate: %ld\n", max);
  314.     printf("Max Frame rate: %ld\n", min);
  315.     printf("Avg Frame rate: %ld\n", avg/num);
  316.     CloseTimer();
  317.     FreeSignal(c2psignal);
  318.     FreeMem(cbuf,CBUF);
  319.     FreeRtgScreenModeReq(sr);
  320.     CloseLibrary((struct Library *)RTGMasterBase);
  321.     CloseLibrary(UtilityBase);
  322. }
  323. //*
  324.  
  325.